Approximate Uni-directional Benders Decomposition

We examine a decomposition approach to find good quality feasible solutions. In particular, we study a method to reduce the search-space by decomposing a problem into two partitions, where the second partition (i.e., the subproblem) contains the fixed solution of the first (i.e., the master). This type of approach is usually motivated by the presence of two sub-problems that are each more easily solved by different methods. Our work is motivated by methods for which it is nontrivial to return a strong ‘no-good’, ‘Benders feasibility’, or ’optimality’ cut. Instead, we focus our attention on a unidirectional decomposition approach. Instead of providing a relaxation of the sub-problem for the master problem, as in Benders decomposition, we provide an approximation of the sub-problem. Thus, we aim at finding good quality feasible solutions in the first iteration. While the quality of the approximation itself affects the impact of this approach, we illustrate that even using a simple approximation can have strong positive impact on two examples: the Travelling Purchaser Problem and a Mine Planning Problem. Consider a class of problems which are not efficiently solved by any one method. A simple, quick-and-dirty method for finding feasible solutions to such problems is to partition them into two subproblems, each of which is more easily solved by different algorithms (see, e.g., (Fernández and Borrajo 2009) and (Flórez et al. 2011)). Such hybrid systems are useful for quickly finding feasible solutions for problems which are otherwise unsolvable. In the naive decomposition, we can split the problem into two partitions by separating the variables into two sets. In the first partition (called the master, in Benders literature), the variables from the second partition (called the sub-problem) are ignored completely. We then solve the master without any knowledge or regard for the components in the subproblem. The subproblem can then be solved by fixing the variables from the master to the solution obtained from the naive solve. If the partitioning is devised such that a solution to the master problem guarantees a feasible solution in the subproblem and thereby a feasible solution to the overall problem, then we have a method for finding feasible solutions more quickly (perhaps) than Copyright c © 2014, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved. solving the full problem. In this paper, we restrict our focus to such cases—i.e., decompositions which guarantee feasibility. We describe a method to improve the solution space produced by the master, by approximating the subproblem within it. If we are using specialised solvers that don’t provide feedback, as in Benders, and solving the full problem to optimality is also not possible, then the alternative is to give up on completeness in order to get a strong approximation. In our case studies, we illustrate this scenario by solving the master using mixed-integer programming and the subproblem by an Automated Planner. However, the approach is not limited to these methods. State-space search is the predominant approach to solving Automated Planning problems (see Section Planning and State-space Search). Typically, such search methods focus on finding feasible solutions—partly because this is all that is required and partly because the state-space can be overwhelmingly large and non-convex. Since planning methods search for paths connecting an initial state to a goal state within an implicitly defined graph, they can be used to solve problems with state-dependent components, which is generally challenging for mixed-integer programming solvers. Considering the full state-space, however, leads to an obvious explosion in the search space. Therefore, decomposition can be necessary to reduce the complexity of these problems and necessary to deal with more expressive planning problems that have continuous, numeric, and temporal variables. Benders Decomposition is a prominent decomposition approach which guarantees optimal solutions for mixedinteger linear systems. In the Benders method, we partition the full problem into a master and subproblem, each of which is easier to solve than the overall problem. This method is based on the concept of projection: a procedure that eliminates dimension from a problem in such a way that the feasible region for the reduced system remains intact. Furthermore, if no solution exists for the projected system, then no solution exists for the original system. Obtaining the correct projection is analogous to performing pivots in Gaussian Elimination—there is usually a residual in the coefficient and/or in the right-hand-side once the projection is obtained. This is the key result on which Benders decomposition is based. The master is originally an overapproximation of the correct projection. Then, in an iterative process, the solution space for the master is pruned back until it is provably the correct projection. Once this is obtained, it is trivial to find the optimal solution. Our approximation is based on the insight that the residual in the correct projection represents the part of the problem that was projected away, or, the subproblem. Instead of eliminating variables as in the quick-and-dirty approach, consider replacing them with an approximation. If the approximation is perfect, then we simply have the original problem. However, in this paper we formulate the approximation in such a way that it both resembles the subproblem and has little computational burden. We use this approximation to drive the master to be closer to the correct projection. We show empirically that the residual can be effectively approximated by even a simple approximation of the subproblem. Benders decomposition and Logic-based Benders decomposition are not automated methods—the partitions must be designed such that strong optimality and feasibility cuts can be returned from the subproblem. This itself is a non-trivial task. Contrarily, in our method we bypass this requirement. The only challenge in our method is to devise an approximation of the subproblem within the master. While the provision of a relaxation of the subproblem within the master has been an important step in Benders and Logic-based Benders since the beginning, the key difference with our method is that the approximation leads to a feasible solution (whereas the relaxation doesn’t guarantee feasibility). Therefore, our method can also be used as a starting solution for Benders decomposition or Logic-based Benders decomposition if the first partition is provably an overestimation—i.e., it does not eliminate all the optimal solutions. In the Section Uni-Directional Decomposition, we outline how this approximation can be achieved in a simple way. We describe our illustrative problems in sections Example 1: The Travelling Purchaser Problem (TPP) and Example 2: Mining Operations Planning (MOP). Both problems are such that solving the entire problem with a planner leads to overwhelmingly large search spaces, and the state-of-theart planners subsequently do not admit solutions. Our experiments (Section Experiments) show that even by creating simple approximations, we obtain strong improvement over naive partitionings on our motivating examples. Planning and State-space Search Planning is the problem of finding a sequence of actions that maps a given initial state to a goal state, where in its simplest form, the environment and the actions are deterministic— this is also known as classical planning. The computational challenge is to devise effective methods to obtain such action sequences, called plans. The last two decades have brought significant advances in classical planning (see, e.g., (Kautz and Selman 1996; Blum and Furst 1995; Bonet and Geffner 2001; Richter and Westphal 2010)), with heuristic search—using search algorithms on the underlying state model guided by heuristic estimators extracted automatically from the problem—being the most successful. For large problems, explicitly enumerating the state space is not feasible. In this scenario, factored representations are used in which states are complete assignments to a set of variables whose domains are finite and discrete. Any graphsearch algorithm can be used in order to find a plan on the underlying state model. Even so, blind search algorithms such as Dijkstra (Cormen et al. 2001) do not scale up due to the size of the state space, which can be exponential in the number of variables in the factored problem. On the other hand, heuristic search algorithms have proven to perform effectively, provided they use a heuristic function sufficiently informed to guide the search. State-of-the-art planners derive heuristic functions automatically from the description of the problem, and use search enhancements to prune the state-space. One of the keys to scaling up is to have accurate heuristic functions in order to explore a reduced amount of the search space. Most of the heuristics are far from optimal, and very small errors can cause an exponential amount of exploration (Helmert and Röger 2008). An alternative solution is to decompose the original problem into a series of more easily solvable subproblems. Moreover, decomposition techniques are widely used to incorporate more expressive problems formalised in different theories. Specialised solvers are then used to deal with such theories, e.g., linear program solvers deal with linear equations and Presburger Arithmetic to reason over continuous effects and metric resources (Coles et al. 2008a; Ivankovic et al. 2014), AC power flow solvers deal with balancing problems in an electricity network (Piacentini et al. 2013), simple temporal network (STN) solvers deal with difference logic to reason over durative actions (Coles et al. 2008b), etc. The following approach reduces the complexity of the planning problem and improves the solution quality outcomes for hybrid systems. Uni-directional Decomposition Let x ∈ Dx and y ∈ Dy be vectors of variables, where the domains may be continuous or integer. Then, let f(x, y) be a function of these variables such that f may contain some part that is not trivially linearisable, such as state-dependent components. As a simple example of state-dependence, let the ‘state’ of the system be given by ṡ(t), at a given time t. Then, a possible function that we are considering in this class is one where the cost function for a particular variable is state-dependent: f(x, y, t) = cx+d (ṡ(t)) y. Such a function can be cumbersome to linearise, because we would need to encode exponentially many ancillary variables to indicate which combinations of events are a part of the current state. Let C(x, y, t) be a set of constraints on x, y and t, where the constraints may contain some part that is not trivially linearisable. Then, we wish to solve problems of the following class: